Javascript interpreter engine written in Java

ABSTRACT

A method and apparatus for interpreting and executing a program may include accessing a program in memory, parsing the program, generating an intermediate representation equivalent of the program, and executing the intermediate representation by accessing the program&#39;s library of host objects through an interface to the library. The program may be a JavaScript program embedded in HTML documents in a browser. The Web browser is programmed to intercept the JavaScript code and pass execution control over the program to the interpreter engine developed in Java. The parsing component of the engine validates the JavaScript instructions. The validated instructions are converted by the code generator component of the engine into an intermediate representation equivalent in Java code. The interpreter engine accesses the program&#39;s library of host objects through an interface to the library and executes the intermediate representation to produce the desired results as programmed in the original JavaScript source program.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates to a method and apparatus for interpreting andexecuting JavaScript programs, such as JavaScript programs embedded inhypertext markup language (“HTML”) documents. More particularly,embodiments of the present invention relate to a method and apparatusfor a JavaScript interpreter written in Java. Specifically, a JavaScriptinterpreter may intercept JavaScript source code within HTML documents,parse and convert the JavaScript source code to a proprietaryintermediate form represented by objects written in Java. The JavaScriptinterpreter may interface with JavaScript library objects to execute theintermediate representation equivalent of the original JavaScript sourcecode.

2. Description of the Related Art

JavaScript is a Web scripting language developed by NetscapeCommunications Corporation. JavaScript was one of the first Webscripting languages and it remains one of the most popular today.(Please note that JAVA and JAVASCRIPT used herein are registeredtrademarks of Sun Microsystems. Inc.) JavaScript may be directlyincluded in HTML documents. HTML is a language used to create Webdocuments. Referring now to FIG. 1, the JavaScript source code istypically embedded in HTML documents 110, by using a script tag, such as“<SCRIPT LANGUAGE=JavaScript>”. A Web browser 120, such as NetscapeNavigator, executes HTML documents containing JavaScript source code.Unlike compiled languages, JavaScript is an interpreted language. Thismeans the Web browser executes each line of JavaScript as it comes toit. The ability to interpret and execute JavaScript source code has beenprovided in popular Web browsers, such as Netscape Navigator andMicrosoft Internet Explorer. JavaScript programs run within a Webbrowser or other JavaScript-enabled applications to produce the desiredresults 130. The JavaScript language is regularly updated by Netscape.The most recent version of JavaScript is version 1.3.

Typical prior art Web browsers that support JavaScript are programmed innative code complied for a particular computer platform. However, it maybe desirable to support JavaScript in a Web browser programmed in aplatform-independent language such as Java. A Java-based Web browser mayrun on any computing platform under a Java Virtual Machine for theparticular platform. However, Java-based programs typically execute moreand may have a larger memory footprint that natively coded programs.Thus, adding JavaScript support to a Java-based browser may exacerbatespeed and memory drawbacks. It may be desirable to overcome thesedrawbacks for a Java-based browser with JavaScript support, especiallyfor use in embedded devices such as personal digital assistants (PDAs),wireless communication devices, such as cellular telephones, and othersmall consumer devices where computer processing speed and memoryresources are at a premium. The present invention may provide a methodand apparatus for interpreting and executing JavaScript source codeembedded in HTML documents. The interpreter of the present invention maybe written using the Java programming language. The present inventionuses a smaller memory footprint than the prior art in interpreting andexecuting JavaScript programs. Furthermore, the architecture of thepresent invention may enable faster execution of JavaScript programs andenable the use of independent implementations of the interpreter, theWeb browser and the JavaScript object library.

SUMMARY OF THE INVENTION

A method and apparatus for interpreting and executing a program isdisclosed. Specifically, a method and apparatus is disclosed foraccessing a program in memory, parsing the program, generating anintermediate representation equivalent of the program, and executing theintermediate representation by accessing the program's library of hostobjects through an interface to the library.

In the preferred embodiment of the present invention, the program to beinterpreted and executed is a JavaScript program embedded in HTMLdocuments in an Internet Web browser. The Web browser is programmed tointercept the JavaScript code and pass execution control over theprogram to the interpreter engine developed using the Java programminglanguage. The parsing component of the engine validates the JavaScriptinstructions. The validated instructions are converted by the codegenerator component of the engine into an intermediate representationequivalent in Java code. The interpreter engine accesses the program'slibrary of host objects through an interface to the library and executesthe intermediate representation to produce the desired results asprogrammed in the original JavaScript source program. The presentinvention further contemplates information media that conveys softwarefor implementing the method disclosed herein.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flow diagram of a typical method of interpreting JavaScriptprograms;

FIG. 2 is a flow diagram illustrating one embodiment of interception ofJavaScript code in HTML for execution by a Java-based JavaScriptinterpreter;

FIG. 3 is a flow diagram illustrating an embodiment of variouscomponents for interpreting JavaScript programs;

FIG. 4 illustrates a method according to one embodiment for convertingJavaScript code to an equivalent intermediate representation; and

FIG. 5 illustrates the hierarchy of the JavaScript runtime objects andits relationship to the hierarchy of library objects, according to oneembodiment.

While the invention is described herein by way of example for severalembodiments and illustrative drawings, those skilled in the art willrecognize that the invention is not limited to the embodiments ordrawings described. It should be understood, that the drawings anddetailed description thereto are not intended to limit the invention tothe particular form disclosed, but on the contrary, the intention is tocover all modifications, equivalents and alternatives falling within thespirit and scope of the present invention as defined by the appendedclaims.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

A preferred embodiment of the present invention may be developed usingthe Java programming language as provided in the Java Development Kit(JDK), version 1.1.7 from Sun Microsystems.

Referring now to FIG. 2, in one embodiment, a JavaScript source programmay be embedded in HTML 210. The HTML may be processed by a Web browser220, such as Netscape Navigator or Microsoft Internet Explorer. AJavaScript tag in the HTML may be used to identify the beginning of theJavaScript code section within the HTML. Upon encountering a JavaScripttag 230, the Web browser may pass execution control to an interpreterengine 250. The interpreter engine 250 may interpret the JavaScript code210, execute it, and present the results to the user 260. Non-JavaScriptcode in the HTML may be executed by the Web browser 240.

The interpreter engine 250 is further illustrated in FIG. 3, accordingto one embodiment. Once the Web browser has identified an input streamof JavaScript source code 310 in the HTML document, the Web browser maypass processing control to a parser component 320 of the interpreterengine. The parser 320 may examine the syntax of the incoming Javascriptsource code 310 to produce a validated listing of JavaScript code 330before the code is translated by the interpreter. The parsed JavaScriptcode 330 may then be processed by a representation generator component340 of the interpreter engine. The representation generator component540 takes as input the validated JavaScript code 330 and produces anintermediate representation using a proprietary Java code equivalent 350of the JavaScript code 310. The intermediate Java code representation350 may then be interpreted by an interpreter component 360. Theinterpreter component 360 may use a library interface 370 to communicatewith a JavaScript host objects library 380 to execute the intermediaterepresentation 350 and produce desired results 390 as programmed in theoriginal JavaScript source program 310.

As one of ordinary skill in the art will appreciate, there are variousmethods by which a Web browser may be enabled to recognize the parsercomponent 320 as the appropriate subroutine to which the Web browserpasses control upon encountering the JavaScript tag 230. One method isby placing “hooks” into the Web browser which instruct the browser tocall certain entry point methods of the parser component 320 when aJavaScript tag is encountered in the HTML code. The general method ofplacing such “hooks” in a Web browser by using the JDK Reflection API iswell known to those of ordinary skill in the art. Other well-knownmethods of instructing one program to invoke another may be applied toinstruct a Web browser to invoke the parser component 320. These methodsinclude use of the “OnAction” keyword and “Form” tag.

In the preferred embodiment of the present invention, the parsercomponent 320 may be written using Java CC, a publicly available utilitypublished by Metamata. Using the Java CC utility, the parser component320 may be written to accept the syntax (grammar) of the input languageto be parsed, i.e., the Javascript syntax. This enables the parsercomponent 320 to parse the input steam of JavaScript source code 310 toensure that the correct syntax is followed. The parser component 320produces a validated listing of JavaScript code 330. The parser 320 maycreate Java objects based on what is parsed from the input stream of theJavaScript source code 310. The Java objects, which may contain fieldnames and methods, may be stored using a technique such as hash tables.The use of hash tables may facilitate fast access of field names andmethods during the entire process of interpreting and executing theJavaScript source code 310.

As stated above, a Java CC source file may define the JavaScript grammarin one embodiment. The following illustrates the creation of Java CCsource file definitions and three related parser methods as used in thepreferred embodiment of the present invention:

PARSER_BEGIN(JvScParser) class JvScParser { static JvScCodeGeneratorcodeGen; . . . boolean parseScript (int lineOffset) throwsParseException { lineNumber = lineOffset; if (Script ( ) ) { if(codeGen.lastPut ( ) == JvScOperator.OP_STMTEND) codeGen.unput () ;codeGen.put (JvScOperator.OP_EOF) ; return true; } return false; } . . .} . . . | < #LETTER: [ “A”-“Z”, “a”-“z”, “$” ] > | #DIGIT: [ “0”-“9” ] >| <IDENTIFIER: <LETTER> (<LETTER> | <DIGIT> ) * > . . . boolean Script () : { } { ( <SEMICOLON> ) * Statement ( ) ( <SEMICOLON> ) * ( Statement( ) ( <SEMICOLON> ) * ) * <EOF> { return true; } | <EOF> { return false;} } /* This is a handler for the JavaScript statement. It delegatescode-generating duties to other handlers depending on the currentstatement type. */ void Statement ( ) : { boolean nonEmpty; } { nonEmpty= StatementBody ( ) { if (nonEmpty) codeGen.put(JvScOperator.OP_STMTEND) ; } | Block (null, false) | SwitchStatement () | WhileStatement ( ) | ForStatement ( ) | DoStatement ( ) |IfStatement ( ) | FunctionDefinition ( ) { codeGen.put(JvScOperator.OP_STMTEND); } | GlobalVarDef ( ) ) . . . /* When a stringof characters satisfying the pattern determined by <IDENTIFIER> (seeabove) has been encountered, it is used to create the JavaScript engineinternal representation of identifiers, JvScName. ‘token.image’ is wherethe string is stored by the parser. */ JvScName Name ( ) : { } {<IDENTIFIER> { return new JvScName (token.image); } }

Once the parser 320 has parsed the input stream of the JavaScriptprogram 310, the parsed JavaScript code 330 may be translated into anintermediate representation Java code 350 by the representationgenerator component 340. The intermediate format of the preferredembodiment may be an arbitrary scheme that is similar to Java byte code.As one skilled in the art will appreciate, the intermediate format maybe any scheme that adequately represents the input JavaScript code 310for execution by a JavaScript interpreter. The representation orintermediate format 350 of the preferred embodiment is particularlysuitable for execution by a stack-machine implemented interpreterwritten in Java. However, as one skilled in the art will readilyappreciate, it is not required that the intermediate format 350 bedesigned such that it may be executed by stack-machine implementedinterpreter. Depending on the representation scheme used, alternativelydesigned interpreters may be used without departing from the presentinvention.

As stated above, the representation of the input JavaScript program 310may be accomplished using many different schemes. The preferredembodiment of the present invention demonstrates one representationscheme using Java classes and objects.

Referring now to FIG. 4, a representation scheme example according to apreferred embodiment is illustrated. The input JavaScript source codesample 410 is “Echo (“2+3:”+(2+));.” The Javascript code 410 performsthe simple function of adding two numbers and displaying the result. Box420 shows a representation of the JavaScript code 410 as it isaccomplished in the preferred embodiment. More particularly, box 430lists logical commands representing the JavaScript code 410, and box 440lists Java objects and classes which correspond to the logicalrepresentations 430. Box 450 illustrates the foregoing with Java programcode. The representation generator 340 may use a stack data structure tostore the intermediate representation 350 as Java objects. For example,the JavaScript function “Echo” is represented with two pushes on thestack data structure. First, the logical command “call” is pushed on thestack to indicate the presence of a function or method. Second, the nameof the function “echo” is pushed on the stack. The Java object “call” isan instance of the Java class JvScFunctionalCall. Similarly, the Javaobject “echo” is an instance of the Java class JvScName, used forstoring host objects. The names of host objects may be names of methodsor functions which are called to perform specific functions. Andsimilarly, Java classes, such as JvScOperator, JvScString and JvScNumbermay be created to hold Java objects, such as the operator “add,” thestring “2+3” and the integer “2” respectively. The parameters andcommands in the intermediate representation may be Java objects.

Referring now to FIG. 5, box 510 illustrates a hierarchy of theJavaScript runtime objects and its relationship to a hierarchy oflibrary objects 580. The class JvScAtom 520 may generally consist of aJvScOperator class 530 and the JvScDatum class 540. The JvScOperatorclass 530 may contain objects such as “MUL,” “ADD,” “CALL”, “GETFIELD”and “RETURN.” The JvScDatum class 540 includes JvScName 550 (e.g., nameof a method or function), JvScNumber 560 (e.g., the integer “2” used inan ADD operation) and JvScObject 570 (which is inserted in the stackdata structure discussed above). As stated above, the representationgenerator 340 may use a stack data structure to store the intermediaterepresentation 350 as Java objects.

The stack used in the representation scheme of the preferred embodimentmay be an array of Java objects. Each element of this array (stack) maybe either a command or a parameter. Each element may derive from anabstract Java class with very generic functionality and may contain datapertaining to the operator or data type it represents, sufficient for astack machine interpreter to perform actions equivalent to thosespecified in the original JavaScript program 310. The Java class towhich an object in the array (stack) belongs, may determine whether theparticular object is a command or a parameter. As one of ordinary skillin the art will appreciate, there are numerous methods of representingin memory the operators and the operands of a compiled program. In thepreferred embodiment of the present invention, the logicalrepresentation 430 uses the well-known Polish notation scheme.

The intermediate representation 350 may have several advantages, such asa small memory footprint. Furthermore, the representation scheme of thepreferred embodiment may enable faster execution of the JavaScript code310 by the interpreter component 360.

The following illustrates the representation generator component 340 ofthe preferred embodiment and an associated representation schemesuitable for execution by a stack-machine implemented interpreter:

void ForStatement ( ) : {} { <FOR> <LPAREN> ForRemainder ( ) } voidForRemainder ( ) : { JvScScope scope = new JvScScope ( ) ; JvScName n =null; } { LOOKAHEAD ( Name ( ) <IN> ) n = Name( ) <IN> { scope.addLocal(n.name) ; } ForInRemainder (scope, n) | LOOKAHEAD ( <VAR> Name ( ) <IN>) <VAR> n = Name ( ) <IN> { scope.addLocal (n.name) ; } ForInRemainder(scope, n) | [ ForInitList(scope) ] <SEMICOLON>TraditionalForRemainder(scope) } void ForInitList (JvScScope scope) : {}{ { /*codeGen.put (scope) ; */ scope = insideFunction; } ( Expression( ){ codeGen.put(JvScOperator.OP_STMTEND); } (LOOKAHEAD(2) <COMMA>Expression( ) { codeGen.put (JvScOperator.OP STMTEND); } ) * ( <COMMA>LocalVarStatement (scope) )? | LocalVarStatement(scope) ) } . . .JvScAtom Literal( ) : { JvScArray a = null; } { <INTEGER> { long num =0; boolean tryDec = false; if (token.image.charAt(0) == ‘0’ &&token.image.length( ) > 1) { if(Character.toUpperCase (token.image.charAt (1)) == ‘X’) num = Long.parseLong (token.image.substring(2), 16) ; else if(qualifyOctal (token.image)) {num = Long.parseLong ( token.image.substring (1) , 8) ; } else { tryDec= true; token.image = token.image.substring(1) ; } } else tryDec = true;if (tryDec) { try { num = Long.parseLong (token.image) ; } catch(NumberFormatException e) { // Most probably the number was too longreturn new JvScBigNumber(token.image); } } return new CacheNumber (num);} | <FLOAT> { return new CacheNumber ( (Double.valueOf (token.image)).DoubleValue ( ) ); } | <STRING> { return new CacheString (token.image.substring (1, token.image.length ( ) −1)); } | <TRUE> {return JvScAtom.JvScTrue; } | <FALSE> { return JvScAtom.JvScFalse; } |<NULL> { return JvScAtom.JvScNull; } | <UNDEFIED> { returnJvScAtom.JvScUndefined; } } . . . JvScOperator AssignOperator ( ) : {} {<ASSIGN> {return JvScOperator.OP_SET; } | <PLUS_ASSIGN> {returnJvScOperator.OP_ADD_SET; } | <MINUS_ASSIGN> {returnJvScOperator.OP_SUB_SET; } | <MUL_ASSIGN> {returnJvScOperator.OP_MUL_SET; } | <DIV_ASSIGN> {returnJvScOperator.OP_DIV_SET; } | <AND_ASSIGN> {returnJvScOperator.OP_AND_SET; } | <OR_ASSIGN> {return JvScOperator.OP_OR_SET;} | <XOR_ASSIGN> {return JvScOperator.OP_XOR_SET; } | <MOD_ASSIGN>{return JvScOperator.OP_MOD_SET; } | <LSHIFT_ASSIGN> {returnJvScOperator.OP_LSH_SET; } | <LSHIFT_ASSIGN> {returnJvScOperator.OP_RSH_SET; } | <RUSHIFT_ASSIGN> {returnJvScOperator.OP_USH_SET; } } . . . public class JvScAtom implementsCloneable { /* ECMAScript compatibility constants to be used by tbetypeof operator. */ static final String typeofUndefined = “undefined”;static final String typeofObject = “object”; static final StringtypeofNull = typeofObject; static final String typeofBoolean =“boolean”; static final String typeofFunction = “function”; static finalString typeofNumber = “number”; static public final JvScAtom JvScTrue =new JvScObject( ); static public final JvScAtom JvScFalse = newJvScObject( ); static public final JvScAtom JvScUndefined = newJvScObject( ); static public final JvScAtom JvScNull = new JvScObject(); static public final JvScNumber JvScNaN = new JvSCNumber(DOuble.NaN);static public final JvScAtom JvScLineNumber = new JvScAtom( ); publicString typeOf( ) { if (this == JvScNull) return typeofNull; else if(this == JvScUndefined) return typeofUndefined; else if (this ==JvScTrue || this == JvScFalse) return typeofBoolean; else if (this ==JvScObject.NaN || this == JvScobject.Infinity) return typeofNumber;return typeofObject; } . . . public class JvScNumber extends JvScAtom {static final String NAN_STRING =“NaN”; static final int MAX_RADIX = 36;static final String TYPEOF_NUMBER = “number”; static final StringMAX_VALUE_STRING = “1.7976931348623157e308”; static final JvScNumberRADIX_10 = new JvScNumber(10); static final JvScNumber JvScZero = newJvScNumber(0); static final JvScNumber JvScOne = new JvScNumber(1);boolean integer; double value; public JvScNumber(int value) { this.value= value; integer = true; public JvScNumber(long value) { this.value =value; integer = true; public JvScNumber(float value) { this.value =value; integer = Math.floor(value) == value; } public JvScNumber(doublevalue) { this.value = value; integer = Math.floor(value) == value; }public JvScNumber(double value, boolean integer) { this.value = value;this.integer = integer; } public JvScNumber(Number value) {this(value.doubleValue( )); } final public boolean isInteger( ) { returninteger; } final public void set(int value) { this.value = value;integer = true; } final public void set(long value) { this.value =value; integer = true; } final public void set(float value) { this.value= value; integer = false; } final public double get( ) { return value; }final public int intValue( ) { return (int)value; } final public longlongValue( ) { return (long)value; } final public float floatValue( ) {return (float)value; } public double doubleValue( ) { return value; }public JvScAtom toNumber( ) { return this; } public JvScAtom toBoolean() { return value == 0.0 || Double.isNaN(value)? JvScFalse : JvScTrue; }public JvScAtom isFinite( ) { return isFiniteboolean( )? JvScTrue :JvScFalse; } public JvScAtom isNaN( ) { return Double.isNaN(value)?JvScTrue : JvScFalse; } boolean isNaNboolean( ) { returnDouble.isNaN(value); } boolean isFiniteboolean( ) { return!Double.isNaN(value) && value < Float.MAX_VALUE && value >−Float.MAX_VALUE; } static String trimSpaces(String str) { inti =0; for( ; i < str.length( ) && (Character.isWhitespace(str.charAt(i)) ||str.charAt(i) == ‘\u000b’); 1++); return i > 0? (i >= str.length( )? “”: str.substring(i)) : str; } static long parseInt(String inStr, intradix) { int i = 0 ; String numstr = trimSpaces(inStr); if(numstr.charAt(i) == ‘−’ || numstr.charAt (i) == ‘+’ ||Character.digit(numstr.charAt(i), radix) >= 0) { for ( ++i; i <numstr.length( ) && Character.digit(numstr.charAt(i), radix) >= 0; i++);} return i < numstr.length( )? Long.parseLong(nurnstr.substring(0,i),radix) : Long.parseLong(numstr, radix); } static doubleparseFloat(String numstr) { int i = 0 ; boolean dot = false;if(numstr.charAt(i) == ‘−’ || numstr.charAt(i) == ‘+’ ||Character.digit(numstr.charAt(i), 10) >= 0) { for( ++i; i <numstr.length( ) && (Character.digit(numstr.charAt(i), 10) >= 0 ||numstr.charAt(i) == ‘.’ && (dot = !dot)); i++); } return Double.valueOf(i <numstr.length( )? numstr.substring(O,i) : numstr). doubleValue( ); }public Object toJavaType( ) { if (integer) return new Long((long)value);else return new Double(value); } public final String toString(JvScAtomradix) throws JavaScriptRuntimeException { double r = radix.doubleValue(); if(Double.isNaN(value) || this == JvScNaN) return NAN_STRING; if((int)r != 10) { if(Double.isNaN(r) || r <= 0 || r > MAX_RADIX) thrownew JavaScriptRuntimeException ( “Illegal radix: ” + radix); returnLong.toString(longValue( ), (int)r); } return value >= Float.MAX_VALUE?MAX_VALUE_STRING: (integer? ““+longValue( ): ””+(float)value); } publicString toString( ) { try { return toString(RADIX_10); }catch(JavaScriptRuntimeException e) { } return NAN_STRING; } publicString typeOf( ) { return TYPEOF_NUMBER; } } . . . public classJvScObject extends JvScAtom { static final String CLS_ARRAY = “Array”;static finai String CLS_OBJECT = “Object”; static final StringCLS_NUMBER = “Number”; static final String CLS_STRING = “String”; staticfinal String CLS_FUNCTION = “Function”; static final StringFLD_PROTOTYPE = “prototype”; static final String FLD_CONSTRUCTOR =“constructor”; static final String FLD_PROTO__= “_proto_”; static finalStiing FLD_LENGTH = “length”; static final String FLD_TOSTRING =“toString”; static final Class[ ] voidClsList = new Class[0]; publicstatic JvScAtom proto_(—) = new JvScObject( ); public static JvScAtomNaN = JvScAtom.JvScNaN; public static JvScAtom Infinity = newJvScObject( ); private static Class STRING_CLASS = “”.getClass( );private static Class JVSCOBJECT_CLASS = proto_.getClass( ); static ClassvarParam[ ]; static { varParam = new Class[1]; varParam[0] = (newJvScAtom[0]).getClass( );    } static Hashtable methods = new Hashtable(); static Hashtable constructors = new Hashtable( ); static HashtablestaticInstances = new Hashtable( ); // static Hashtable prototype = newHashtable( ); protected Hashtable properties; static private StringobjectPrefix = “[object”; private static StringtoStringClassName(JvScObject object) { String clsName = null; /*  * Thisfunction is completely meaningless  * if not for ECMA, wouldn't ever bewritten.  */ if(object instanceof JvScPrototype) clsName =className(((JvScPrototype)object).getTargetClass( )); else if(objectinstanceof JvScNativeFunction) clsName = CLS_FUNCTION; else { /* Objectm = object.properties.get(FLDTOSTRING); if (m != null && m instanceofJvScNativeFunction && ((JvScNativeFunction)m).className.compareTo(CLS_OBJECT) == 0) { } else try { if(object.getClass().getDeclaredMethod(FLD_TOSTRING, voidClsList) != null) returnobject.toString( ); } catch(NoSuchMethodException e) { } */ clsName =className(object.getClass( )); } return objectPrefix + clsName +“]”; }static final String className(Class cls) { String name = cls.getName( );return name.substring(name.lastIndexOf(“.”) + 1); } Public staticJvScAtom fromJavaType(Object o) { if(o instanceof java.lang.String)return new JvScString((java.lang.String)o); else if(o instanceofjava.lang.Number) return new JvScNumber((java.lang.Number)o); return newJavaObject(o); } static final JvScObject castToJvScObject(Object object){ return (JvScObject)(object instanceof JvScObject? object: newJavaObject(object)); } static JvScObject newInstance(Class cls,JvScAtom[ ] mem, imt p1, int n) throws JavaScriptRuntimeException {return newInstance(cls, mem, p1, n, false); } static JvScObjectnewInstance(Class cls, JvScAtom[ ] mem, int p1, int n, booleanjavaClass) throws JavaScriptRuntimeException { Constructor constructor[]; JvScObject re = null; if(n <= 0) { try { re =castToJvScObject(cls.newInstance( )); } catch(Exception e) { throw newJavaScriptRuntimeException( “EXCEPTION trying to invoke constructor of“ + cls + “:”+e); } } else { int i = 0; if((constructor=(Constructor[])constructors.get(cls)) == null) constructors.put(cls, constructor =cls.getConstructors( )); for( i = 0; i < constructor.length &&constructor[i] .getParameterTypes( ).length != n; i++); if(i >=constructor.length) { Constructor cnstr; /*  * Try to findthis(JvScAtom[ ] varp)  */ try { cnstr = cls.getConstructor(varParam); }catch(Exception e) { throw new JavaScriptRuntimeException( “There is noconstructor of class ‘” + className(cls) +”\’ accepting “ + n +”parameter(s) ”); } re = newInstance(cnstr, mem, p1, n); } else if(javaClass) { try { return newJavaInstance( constructor[i], mem, p1, n);} catch(Exception e) { throw new JavaScriptRuntimeException( “Exceptioncaught trying instantiate ‘“ + cls + “\’ ”); } } else try { JvScAtom[ ]param = new JvScAtom[n]; System.arraycopy(mem, p1, param, 0, n); re =(JvScObject)constructor[i].newInstance(param); } catch(Exception e) {throw new JavaScriptRuntimeException( “EXCEPTION trying to invokeconstructor of” + “\’: ”+e); } } JvScPrototype proto = null; try { proto= (JvscPrototype)getStaticInstance(cls.getName( )).getField(FLD_PROTOTYPE); } catch(Exception e) { return re; } if (proto!= null) initFieldsFromPrototype(re, proto); return re; } static privateJvScObject newJavaInstance(Constructor c, JvScAtom[ ] mem, int p1, intn) throws JavaScriptRuntimeException { try { return new JavaObject(c.newInstance(JavaObject.atomsToObjects(mem, p1, n))); } catch(Exceptione) { throw new JavaScriptRuntimeException( “Exception in constructor” +c + “: ” + (e instanceof InvocationTargetException?((InvocationTargetException)e). getTarget(Exception( ).toString( ) :e.toString( ))); } } static private JvScObject newInstance(Constructorc, JvScAtom[ ] mem, int p1, int n) throws JavaScriptRuntimeException {Object[ ] p = new Object[1]; JvScAtom[ ] param = new JvScAtom[n];System.arraycopy(mem, p1, param, 0, n); p[0] = param; try { returncastToJvScObject(c.newInstance(p)); } catch(Exception e) { throw newJavascriptRuntimeException( “Exception in constructor” + c + ”: ” + (einstanceof InvocationTargetException? ((InvocationTargetException)e).getTargetException( ).toString( ) : e.toString( )) ); } } classJvScOperator extends JvScAtom { static final byte ARITHM = 1; staticfinal byte ASSIGN = 2; static final byte ACCESS = 3; static final byteLOGIC = 4; static final byte CONTRL = 5; static final byte INCDEC = 6;static final JvScOperator OP_NOP = new JvScOperator(0, “<nop>”); staticfinal JvScOperator OP_EOF = new JvScOperator(0, “<stop>”); // returnstatic final JvScOperator OP_RET = new JvScOperator(0, “<ret>”); //return, unload static final JvScOperator OP_RETU = new JvScOperator(0,“<retu>”); // return void static final JvScOperator OP_RETV = newJvScOperator(0, “<retv>”); // return void, unload static finalJvScOperator OP_RETVU = new JvScOperator(0, “<retvu>”); // functiondefinition static final JvScOperator OP_DEFUN = new JvScOperator(0,“<defun>”); static final JvScOperator OP_BLKEND = new JvScOperator(0, “}<end>”); static final JvScOperator OP_UNLOAD = new JvScOperator(0, “}<end-unload>”); static final JvScOperator OP_POP = new JvScOperator(0,“<pop>”); static final JvScOperator OP_STMTEND = OP_POP; static finalJvScOperator OP_UNWITH = new JvScOperator(0, “<senza>”); static finalJvScOperator OP_WITH new JvScOperator(1, “<con>”); static finalJvscOperator OP_TYPEOF = new JvScOperator(1, “<typeof>”); static finalJvScOperator OP_DELETE = new JvScOperator(1, “<delete>”); static finalJvScOperator OP_VOID = new JvScOperator(1, “<void>”); // It's a specialget-indices method used primarily // by the for(x in y) statement.static final JvScOperator OP_GET_INDX = new JvScOperator(1,“<indices>”); static final JvScOperator OP_MINUS = new JvScOperator(1,“u−”); static final JvScOperator OP_PLUS = new JvScOperator(1, “u+”);static final JvScOperator OP_NEG = new JvScOperator(1, “˜”); staticfinal JvScOperator OP_NOT = new JvScOperator(1, “!”); static finalJvScOperator OP_INCP = new JvScOperator(1, “.++”, INCDEC); static finalJvScOperator OP_DECP = new JvScOperator(1, “.−−”, INCDEC); static finalJvScOperator OP_INC = new JvScOperator(1, “++.”, INCDEC); static finalJvScOperator OP_DEC = new JvScOperator(1, “−−,”, INCDEC); static finalJvScOperator OP_DIV = new JvScOperator(2, “/”, ARITHM); static finalJvScOperator OP_MUL = new JvScOperator(2, “*”, ARITHM); static finalJvScOperator OP_MOD = new JvScOperator(2, “%”, ARITHM); static finalJvScOperator OP_ADD = new JvScOperator(2, “+”, ARITHM); static finalJvScOperator OP_SUB = new JvScOperator(2, “−”, ARITHM); static finalJvScOperator OP_RSH = new JvScOperator(2, “>>”, ARITHM); static finalJvScOperator OP_LSH = new JvScOperator(2, “<<”, ARITHM); static finalJvScOperator OP_USH = new JvScOperator(2, “>>>”,ARITHM); static finalJvScOperator OP_BIT_OR = new JvScOperator(2, “|”, ARITHM), static finalJvScOperator OP_BIT_XOR = new JvScOperator(2, “{circumflex over ( )}”,ARITHM), static final JvScOperator OP_BIT_AND = new JvScOperator(2, “&”,ARITHM); static final JvScOperator OP_GT = new JvScOperator(2, “>”,LOGIC); static final JvScOperator OP_LT = new JvScOperator(2, “<”,LOGIC); static final JvScOperator OP_GE = new JvScOperator(2, “>=”,LOGIC); static final JvScOperator OP_LE = new JvScOperator(2, “<=”,LOGIC); static final JvScOperator OP_EQ = new JvScOperator(2, “==”,LOGIC); static final JvScOperator OP_NE = new JvScOperator(2, “!=”,LOGIC); static final JvScOperator OP_SET = new JvScOperator(2, “=”,ASSIGN); static final JvScOperator OP_ADD SET = new JvScOperator(2,“+=”, ASSIGN); static final JvScOperator OP_SUB_SET = newJvScOperator(2, “−=”, ASSIGN); static final JvScOperator OP_MUL_SET =new JvScOperator(2, “*=”, ASSIGN); static final JvScOperator OP_DIV_SET= new JvScOperator(2, “/=”, ASSIGN); static final JvScOperatorOP_MOD_SET = new JvScOperator(2, “%=”, ASSIGN); static finalJvScOperator OP_AND_SET = new JvScOperator(2, “&=”, ASSIGN); staticfinal JvScOperator OP_XOR_SET = new JvScOperator(2 “{circumflex over( )}=”, ASSIGN); static final JvScOperator OP_OR_SET = newJvScOperator(2, “|=”, ASSIGN); static final JvScOperator OP RSH SET =new JvScOperator(2,“>>=”, ASSIGN); static final JvScOperator OP LSH SEF= new JvScOperator(2,“<<=”, ASSIGN); static final JvScOperator OP USHSET = new JvScOperator(2,“>>>=”, ASSIGN); /* Access Operations */ staticfinal JvScOperator OP_ACS_ARR = new JvScOperator(2, “[ ]”, ACCESS);static final JvScOperator OPACS_OBJ = new JvScOperator(2, “−>”, ACCESS);static final JvScOperator OP_FUN_CALL = new JvScOperator(−1, “<call>”);static final JvScOperator OP_NEW = new JvScOperator(−1, “<new>”); byteopArity; byte type; String opSign; JvScOperator(byte opArity, StringopSign) { this.opArity = opArity; this.opSign = opsign; }JvScOperator(int opArity, String opSign) { this(opArity, opsign,CONTRL); } JvScOperator(int opArity, String opSign, byte type) {this((byte)opArity, opSign); this.type = type; } public String toString() { return opSign; } } if (image == null) image = new StringBuffer(newString(input_stream.GetSuffix(jjimageLe n + (lengthOfMatch =jjmatchedPos + 1)))); else image.append(newString(input_stream.GetSuffix(jjimageLen + (lengthOfMatch =jjmatchedPos + 1)))); ++JvScParser.lineNumber; break; default: break; }} }

Once the representation generator 340 has translated the parsedJavaScript code 330 to produce the intermediate representation 350, theinterpreter component 360 may use the library interface 370 tocommunicate with the JavaScript host objects library 380 to execute theintermediate representation 350 and produce the desired results 390, asprogrammed in the original JavaScript source program 310.

The interpreter 360 may pop elements off the stack, executes them andplaces the result back on the stack. The interpreter may execute streamsof Java objects (e.g., “push” and “2+3”) in the stack containingcommands and parameters belonging to various Java classes (e.g.,JvScOperator or JvScString). The interpreter may pop one or moreelements off the stack depending on what instruction is being executed.For example, if an “ADD” operator is encountered, then the interpreterknows that it must pop two more elements which will form the operandsfor the “ADD” operation. The following illustrates the execution of theintermediate representation Java code 350 by the interpreter 360,according to one embodiment:

public class StackMachine { . . . private JvScAtom executeScript(JvScAtom[] word, int start, JvScBrowserContext bc) throwsJavaScriptRuntimeException { if (bc != null) initContext(browserContext= bc) ; . . . for ( pc = start; ; pc++) { if ( (w=word[pc] ) instanceofJvScOperator) { . . . case JvScOperator.ARITHM: arithmetic(w, n, n2) ;break; . . . } else stack [++sp] = w; } } private JvScAtom arithmetic(JvScAtom w, JvScNumber n, JvScNumber n2) throwsJavaScriptRuntimeException { if (w == JvScOperator.OP_ADD || w ==JvScOperator.OP_ADD_SET) shadowNumber [sp − 1] . value = n.value +n2.value; if (w == JvScOperator.OP_SUB || w == JvScOperator.OP_SUB_SET)shadowNumber [sp − 1] . value = n.value − n2.value; // etc., . . .return stack [sp − 1] = shadowNumber [sp − 1] ; }

Referring to FIG. 3, the interpreter component 360 may use the libraryinterface 370 to communicate with the JavaScript host objects library380 to execute the intermediate representation 350. In a JavaScriptprogram execution environment, there may be several functionallyindependent components. The Javascript interpreter and the JavaScriptlibrary are two of the most important components. In a preferredembodiment, the JavaScript program execution environment may beimplemented using the Java programming language. The preferredembodiment may provide a mechanism whereby host objects in a JavaScriptlibrary are accessible to the interpreter in an execution environmentdesigned in Java.

The method and system of the preferred embodiment may provide aninterface 370 between the JavaScript interpreter 360 and the JavaScriptlibrary objects 380, where both the interpreter 360 and the libraryobjects 380 are written in Java. The interface 370 enables theimplementation of the interpreter 360 to be independent of theimplementation of the library objects 380. Furthermore, theimplementation of the interpreter 360 may be independent of the HTMLbrowser 220 in which it runs. The foregoing relationship between theinterpreter, the library objects and the browser may make it possible toeasily incorporate the interpreter in any Java-enabled browser with anarbitrary library objects implementation.

Still referring to FIG. 3, the library objects 380 may be derived fromabstract Java classes. The interpreter 360 may use the JDK ReflectionAPI for at least two purposes. First, the Reflection API may enable theinterpreter 360 to access specific information (such as properties)about known objects and classes in the library 380. Such information mayinclude, for example, the availability of particular fields and methodswithin objects. Second, the Reflection API may enable the interpreter360 to execute methods if they are not privately protected. Theinterface 370 may also enable manipulation of field values and callmethods of an object. Additionally, fields and methods may bedynamically added or deleted in a class or object. The techniques ofhash tables and the JDK Reflection API may be utilized to facilitate theforegoing processing.

One JavaScript standards specification requires five basic host objectsthat must be present in the local library of a JavaScript interpreter.All other objects that are called by a JavaScript program must beavailable in other libraries accessible to the JavaScript interpreter.The programmer of the JavaScript source code must know what objects,other than the five basic host objects, are accessible to theinterpreter which will execute the JavaScript source code. The Webbrowser in which the JavaScript program runs may provide additionalnon-required host objects in its libraries. As one of ordinary skill inthe art will appreciate, new fields and methods may be added or deletedto any object during run time.

As defined by a JavaScript standards specification, an object inJavaScript does not necessarily only bear traces of the class to whichit belongs. The JavaScript object may have characteristics that aredifferent from other objects belonging to the same class. Thus, objectsin JavaScript may act as independent entities with methods and fieldswhich may be different from the methods and fields in other objectsbelonging to the same class. However, objects in the same class may havecertain basic methods and fields in common.

Still referring to FIG. 3, during the processing of the JavaScriptsource code 310 in the preferred embodiment, the interpreter encountersfields and methods in the JavaScript program. The interpreter may createJava objects in a library containing the fields and the methods.However, as the input stream of JavaScript source code is processed, theinterpreter may learn more information about fields and methods which ithas previously encountered. The library interface 370 may provide theinterpreter 360 the dynamic capability to update Java objects and theirrelated properties or attributes.

In an embodiment, the library interface 370 may have three primary Javamethods through which any interaction with an object 380 is carried out.The three primary Java methods may be “get field,” “set field” and“invoke method.” These methods may be used in conjunction withJavaScript objects and classes whose methods and fields are known to theJavaScript library 380, but not known to the interpreter 360. TheReflection API may be used to access the JavaScript library 380 and thusinform the interpreter 360 about methods and fields contained in anyparticular object.

The JavaScript library 380 may contain a static set of predefinedobjects containing methods and fields. In one embodiment, all objectswithin the input stream of JavaScript source code 310 must exist in theJavaScript library 380. However, certain objects within the JavaScriptsource code 310 may contain methods and fields which are not known tothe JavaScript library 380. When this occurs, the JavaScript library 380may be dynamically updated with the new methods and fields. Similarly,the interpreter 360 may need to be aware of the new methods and fields.The dynamic update of the library 380 may be accomplished with the useof hash tables. In a preferred embodiment, the JavaScript library 380may include a hash table for each object. Initially, the hash table foreach object may be empty. When the input JavaScript program 310introduces a new method or field, an entry may be created in the hashtable corresponding to the new method or field. The name of the newmethod or field may be used as the key to the hash table entry. The keyserves as the means by which the new method or field may be accessed toacquire information about the method or field. For methods, theinformation to be accessed may be the code section associated with thenew method, and for fields, the information to be accessed may be thedata holder or the field value. The interpreter 360 may access the hashtables to get values of the new fields and to execute the codeassociated with the new methods.

The newly added fields and methods in the hash tables may remainavailable to all JavaScript program and interpreter invocations so longas the current session of the HTML browser 220 is running. Once the HTMLbrowser 220 is closed, the newly updated methods and fields in the hashtables may be lost and therefore, the methods and fields may not beavailable to future JavaScript program and interpreter invocations in asubsequent session of the HTML browser. The clearing of the new methodsand fields in the hash tables at the end of an HTML browser session maybe done pursuant to a JavaScript standards specification.

In the preferred embodiment the source code associated with the newlyadded methods is not compiled when a reference to it is stored in thehash table. Instead, an intermediate representation is stored within theengine. This technique may solve certain problems encountered by theprior art. Some prior art methods compile the source code associatedwith the newly added methods and store the new source code in objectcode format for future use. The prior art technique is not efficientbecause it uses large amounts of memory to store the compiled objectcode and uses valuable processing time to convert the source code toobject code. In the present invention, these problems may be overcome bystoring an intermediate representation of the original JavaScriptsyntax.

The present invention does not require that the library host objects 380(and their associated methods) be written in Java. The objects andmethods may be native code but the entry point is written in Java, in apreferred embodiment, because in the preferred embodiment theinterpreter 360 may require methods to have a Java entry point so thatthe interpreter 360 can call on such routines.

One desirable attribute of the present invention may be the independenceand interchangeability of the JavaScript library 380. The preferredembodiment may include one implementation of the JavaScript library 380.This implementation may be written in Java based on a JavaScriptstandards specification. The JavaScript library 380 may be independentof the interpreter 360. Therefore, any other implementation of theJavaScipt library 380 may be easily substituted for the library used inthe preferred embodiment. As mentioned previously, both the interpreterand the JavaScript library may also be independent of the HTML browser.The independence and interchangeability of the JavaScript library maypermit customization of the library to different environments, such asthrough the addition of objects, and their corresponding methods andfields, that may be better suited to certain HTML browsers.

The following illustrates how the interpreter component 360 may use thelibrary interface 370 to communicate with the JavaScript host objectslibrary 380 to execute the intermediate representation 350, according toone embodiment:

public abstract class LibObject extends JvScObject { private staticJvScBrowserContext context = null; public static voidsetContext(JvScBrowserContext contxt) {context = contxt;} public staticJvScBrowserContext getContext( ) {return context:} protected JvScAtomgetField(java.lang.String name) throws JavaScriptRuntimeException {java.lang.String s = “get_” + name; try {m = getClass( ) ,getMethod(s,null);} catch(Exception e) {m = null;} if (m != null) { try {return(JaScAtom) (m.invoke(this, null) );} catch (Exception e) { // fall back}} return super.getField(name) ; } protected JvScAtomsetField(java.lang.String name, JvScAtom value) throwsJavaScriptRuntimeException { java.lang.String s = “set_” + name;JvScAtom[ ] args = new JvScAtom[1] ; args [0] = value; try { // thisuses the Reflection API to find the // field whose name is specified by‘name’. The // value of s specifies what method should be // called toset the field. return invokeMethod(s, args, 0, 1) ;   } catch(Exceptione) { //just fall back } return super.setField(name, value) ; } } classJvScObject extends JvScAtom { protected JvScAtom getField(String name)throws JavaScriptRuntimeException { JvScAtom val = properties == null?null : (JvScAtom)properties.get(name) ; if(val == null) { // Reflectionis being used: try { return (JvScAtom) this. getClass( ) .getField(name).get(this) ; } catch(NoSuchFiledExcepfion e) { . . . } } } /* Howmethods of JavaScript (host) objects are invoked: */ protected JvScAtominvokeMethod(String name, JvScAtom mem[], int p1, int n) throwsJavaScriptRuntimeException { /* An auempt to access a user-definedmethod */ if (properties != null) try { JvScFuncfion f = /* Try to castit to JvScFunction. If we are not  caught into an * exception, it'sreally a  function. */  (JvScFunction)properties.get(name) ; if(f !=null) { if(! (f instanceof JvScMethod) ) properties.put (name, f=newJvScMethod (this, f) ); return (JvScAtom) f; } } catch(Exception e) {System.out.printIn (name + “ is a field, not method : ” + properties.get(name) ) ; } int i; JvScAtom[] param; Method method[] = null; if ((method = (Method[])methods.get (this.getCalss( ) ) ) == null)methods.put(this.getClass( ) , for ( i = 0; i < method.length &&(method[i].getName( ) . compareTo (name) != 0 || method[i].getParameterTypes ( ) .length != n || (n > && method[i].getParameterTypes ( ) [0] == varParam[0]) ) ; i++) ; if (i >=method.length) { Method m; /* Try to find method (JvScAtom[] varp) */try { m = this.getClass ( ) getMethod (name, varParam) ; } catch(Exception e) { throw new JavaScriptRuntimeException( “There is nomethod ‘” + className (this.getClass ( ) ) + “.“ + name + “( )\accepting“ + n + “ parameter(s) . ”, JavaScriptRuntimeExcep-tion.NO_SUCH_METHOD ) ; return invokeMethod(m, mem, p1, n) ; } try {if(n > 0) { param = new JvScAtom[n] ; System.arraycopy (mem, p1, param,0, n) ; } return (JvScAtom)method[i] .invoke(this, param) ; } catch(Exception e) { if (e instanceof InvocationTargetException) { if ( ((InvocationTargetException) e) .getTargetExcep- tion ( ) instanceofJavaScriptRuntimeException) throw (JavaSCriptRuntimeException) ((InvocationTargetException) e) . getTargetException( ) ; } throw newJavaScriptRuntimeException ( “EXCEPTION caught while trying to invokemethod ‘ ” + name + ” ’: “ + (e instanceof InvocationTargetException? ((InvocationTargetException) e). getTargetException( ) . toString( ) :e.toString( ) ) ) ; } { protected JvScAtom invokeMethod (Method method,JvScAtom mem[], int p1, int n) throws JavaScriptRuntimeException {Object[] p = new Object[1] ; JvScAtom[] param = new JvScAtom[n] ;System.arraycopy(mem, p1, 0, n) ; P[0] = param; try { Return(JvScAtom)method.invoke(this, p) ; } catch(Exception e) { throw newJavaScriptRuntimeException ( “Exception in method “ + method + ”: “ + (einstance of InvocationTargetException? ( (InvocationTargetException) e). getTargetException( ) .toString( ) : e.toString( ) ) ) ; } } . . . }static final void initFieldsFromPrototype(JvScObject o, JvScPrototypeproto) throws JavaScriptRuntimeException { Object key;  for(Enumeratione = proto.properties.keys( );  e.hasMoreElements( ); )  { key =e.nextElement( ); o.setField(key.toString( ),(JvScAtom)proto.properties.get(key));  } } public JvScAtom eval(JvScAtomcode) { return null; } public void setProperty(String name, JvScAtomvalue) { if (properties == null) properties = new Hashtable( );properties.put(name, value); } protected JvScAtom setField(String name,JvScAtom val) throws JavaScriptRuntimeException { if(name.compareTo(FLDPROTOTYPE) == 0) return val; if(properties == null ||properties.get(name) == null) { /*  * If there is no user defined fieldunder  * this name, maybe there is the real field. */ try {this.getClass( ).getField(name).set (this, val); return val; }catch(IllegalAccessException ie) { /* that means the field is final ornon-  public.  * In any case ignore this assignment. */ return val; }catch(Exception e) { if(!(e instanceof NoSuchFieldException)) throw newJavaScriptRuntimeEx- ception( “Access error: ” + this.getClass( ) +“cannot set “” + name + “\‘:” + e ); } } /* * Access the user-definedproperties table */ setProperty(name, val); return val; } publicJvScAtom getProperty(String name) { return properties == null? null :(JvScAtom)properties.get(name);} private Exception savedException;protected JvScAtom getField(String name) throwsJavaScriptRuntimeException  { JvScAtom val = properties == null? null :(JvScAtom)properties.get(name); if(val == null) { try { return(JvScAtom)this. getClass ( ) .getField(name) .get(this); }catch(NoSuchFieldException e) { try { return new JvScNativeFunction(this.getClass( ).getName( ), this.getClass( ).getMethod(name, null) }catch(Exception ex) { savedException = ex; } } catch(Exception ex2) {savedException = ex2; } throw new JavaScriptRuntimeException(“Accesserror:” + “cannot get field ‘” + className(this.getClass( )) + “.” +name + “\‘:” + savedException ) ; } return val; } booleanhasMethod(String name) { if (properties != null) if(propcrties.get(name)!= null) return true; Method method[] = (Method[])meth-ods.get(this.getClass( )); if (method != null) for( int i=0; i <method.length; i++) if (method [i] . getName ( ) . compareTo (name) ==0) return true; return false; } protected JvScAtom invokeMethod(Stringname, JvScAtom mem[], int p1, int n) throws JavaScriptRuntimeException

Although the forgoing description has focused on Java implementations,other similar programming languages may be used as well. Any of theforegoing embodiments may be implemented by programming a suitablegeneral-purpose machine having appropriate hardware. The machine maycomprise a single computer or computing device. Alternatively, themachine may comprise a plurality of computers or computing devicesconnected by a communications link.

Various embodiments may further include receiving, sending or storinginstructions and/or data implemented in accordance with the foregoingdescription upon a carrier medium. Generally speaking, a carrier mediummay include storage media or memory media such as magnetic or opticalmedia, e.g., disk or CD-ROM, volatile or non-volatile media such as RAM(e.g. SDRAM, DDR SDRAM, RDRAM, SRAM, etc.), ROM, etc. as well astransmission media or signals such as electrical, electromagnetic, ordigital signals, conveyed via a communication medium such as networkand/or a wireless link.

It will be appreciated by those of ordinary skill having the benefit ofthis disclosure that the illustrative embodiments described above arecapable of numerous variations without departing from the scope andspirit of the invention. Various modifications and changes may be madeas would be obvious to a person skilled in the art having the benefit ofthis disclosure. It is intended that the following claims be interpretedto embrace all such modifications and changes and, accordingly, thespecifications and drawings are to be regarded in an illustrative ratherthan a restrictive sense.

1. A method, comprising: a first process detecting one or more scriptlanguage instructions in a markup language document, wherein the firstprocess is implemented in a platform-independent programming language;generating an intermediate representation of the one or more scriptlanguage instructions, wherein the intermediate representation of theone or more script language instructions is different from the scriptlanguage; and interpreting and executing each of one or moreinstructions of the intermediate representation, wherein saidinterpreting and executing accesses one or more program objects toimplement the one or more instructions of the intermediaterepresentation; wherein said interpreting and executing produces resultsin accordance with the original one or more script languageinstructions.
 2. The method as recited in claim 1, wherein the firstprocess is a Web browser, the method further comprising: the Web browserpassing execution to an interpreter engine after said detecting the oneor more script language instructions in the markup language document;wherein said generating, said interpreting and executing, and saidaccessing one or more program objects are performed by the interpreterengine.
 3. The method as recited in claim 1, wherein the one or moreinstructions of the intermediate representation are stored in a stackdata structure, and wherein said interpreting and executing is performedby a stack-machine interpreter engine that pops the one or moreinstructions off the stack data structure during said interpreting andexecuting.
 4. The method as recited in claim 1, wherein said generatingan intermediate representation of the one or more script languageinstructions comprises validating that the one or more script languageinstructions conform to script language syntax.
 5. The method as recitedin claim 1, wherein said generating an intermediate representation ofthe one or more script language instructions comprises modifying a firstof the one or more program objects.
 6. The method as recited in claim 5,wherein said modifying the first program object comprises adding atleast one of methods and fields to the first program object.
 7. Themethod as recited in claim 5, wherein said modifying the first programobject comprises deleting at least one of methods and fields from thefirst program object.
 8. The method as recited in claim 1, wherein theone or more program objects are accessed from one or more objectlibraries.
 9. The method as recited in claim 1, wherein the scriptlanguage is JavaScript.
 10. The method as recited in claim 1, whereinthe markup language is Hypertext Markup Language (HTML).
 11. The methodas recited in claim 1, wherein each of the one or more instructions ofthe intermediate representation is represented as one or more Javaobjects each referencing one of the one or more program objects accessedin implementing the one or more instructions of the intermediaterepresentation.
 12. The method as recited in claim 11, wherein each ofthe one or more Java objects of the intermediate representationrepresents one of an operator and an operand of the particularinstruction of the intermediate representation.
 13. The method asrecited in claim 1, wherein the one or more program objects are Javaobjects.
 14. The method as recited in claim 1, wherein theplatform-independent programming language is the Java programminglanguage.
 15. The method as recited in claim 1, wherein the firstprocess is a Java-based Web browser executing within a Java VirtualMachine.
 16. A method, comprising: a Web browser implemented in aplatform-independent programming language examining a current tag of amarkup language document marking the beginning of a portion of themarkup language document; if said examining determines the current tagof the markup language document identifies the portion of the markuplanguage document as comprising script language instructions, passingexecution to an interpreter engine implemented in theplatform-independent programming language; and if said examiningdetermines the current tag of the markup language document does notidentify the portion of the markup language document as comprisingscript language instructions, the Web browser executing the portion ofthe markup language document identified by the current tag; wherein theinterpreter engine is configured to perform the script languageinstructions to produce results in response to said passing execution.17. The method as recited in claim 16, wherein the interpreter engineexecuting the script language instructions comprises: generating anintermediate representation of the script language instructions; andinterpreting and executing each of one or more instructions of theintermediate representation, wherein said interpreting and executingaccesses one or more program objects from one or more object librariesto implement the one or more instructions of the intermediaterepresentation; wherein said interpreting and executing produces resultsin accordance with the original script language instructions.
 18. Themethod as recited in claim 17, wherein each of the one or moreinstructions of the intermediate representation is represented as one ormore Java objects each referencing one of the one or more programobjects accessed in performing the one or more instructions of theintermediate representation.
 19. The method as recited in claim 17,wherein the one or more program objects are Java objects.
 20. The methodas recited in claim 16, wherein the script language is JavaScript. 21.The method as recited in claim 16, wherein the markup language isHypertext Markup Language (HTML).
 22. The method as recited in claim 16,wherein the platform-independent programming language is the Javaprogramming language.
 23. The method as recited in claim 16, wherein theWeb browser and the interpreter engine are executing within a JavaVirtual Machine.
 24. A device, comprising: a processor; a memory coupledto said processor and operable to store program instructions in aplatform-independent programming language, wherein the programinstructions are executable by the processor to: detect one or morescript language instructions in a markup language document; generate anintermediate representation of the one or more script languageinstructions, wherein the intermediate representation of the one or morescript language instructions is different from the script language; andinterpret and execute each of one or more instructions of theintermediate representation to produce results in accordance with theoriginal one or more script language instructions; wherein, in saidinterpreting and executing, the program instructions are furtherexecutable by the processor to access one or more program objects toimplement the one or more instructions of the intermediaterepresentation.
 25. The device as recited in claim 24, wherein theprogram instructions implement a Web browser and an interpreter engine,wherein the Web browser is executable by the processor to perform saiddetecting one or more script language instructions, and wherein the Webbrowser is further executable by the processor to pass execution to theinterpreter engine after said detecting, and wherein the interpreterengine is executable by the processor to perform said generating, saidinterpreting and executing, and said accessing one or more programobjects.
 26. The device as recited in claim 25 wherein the programinstructions further implement a Java Virtual Machine executable by theprocessor within the device, and wherein the Web browser is a Java-basedWeb browser executable within the Java Virtual Machine.
 27. The deviceas recited in claim 24, wherein, in said generating an intermediaterepresentation of the one or more script language instructions, theprogram instructions are further executable by the processor to modify afirst of the one or more program objects.
 28. The device as recited inclaim 27, wherein, in said modifying a first of the one or more programobjects, the program instructions are further executable by theprocessor to add at least one of methods and fields to the first programobject.
 29. The device as recited in claim 27, wherein, in saidmodifying a first of the one or more program objects, the programinstructions are further executable by the processor to delete at leastone of methods and fields from the first program object.
 30. A Thedevice as recited in claim 24, wherein, in said generating anintermediate representation of the one or more script languageinstructions, the program instructions are further executable by theprocessor to validate that the one or more script language instructionsconform to script language syntax.
 31. The device as recited in claim24, wherein the one or more program objects are accessed from one ormore object libraries.
 32. The device as recited in claim 31, whereinthe memory is further operable to store the one or more objectlibraries.
 33. The device as recited in claim 24, wherein the scriptlanguage is JavaScript.
 34. The device as recited in claim 24, whereinthe markup language is Hypertext Markup Language (HTML).
 35. The deviceas recited in claim 24, wherein each of the one or more instructions ofthe intermediate representation is represented as one or more Javaobjects each referencing one of the one or more program objects accessedin implementing the one or more instructions of the intermediaterepresentation.
 36. The device as recited in claim 24, wherein the oneor more program objects are Java programming language objects.
 37. Thedevice as recited in claim 24, wherein the platform-independentprogramming language is the Java programming language.
 38. A device,comprising: a processor; a memory coupled to said processor and operableto store program instructions in a platform-independent programminglanguage, wherein the program instructions implement a Web browser andan interpreter engine; wherein the Web browser is executable by theprocessor to: process a markup language document comprising a scriptcomprising one or more script language instructions; detect the scriptin the markup language document; and provide the script to theinterpreter engine; wherein the interpreter engine is executable by theprocessor to execute the script to produce results of the script. 39.The device as recited in claim 38, wherein the platform-independentprogramming language is Java, wherein the program instructions furtherimplement a Java Virtual Machine executable by the processor within thedevice, and wherein the Web browser and the interpreter engine areexecutable within the Java Virtual Machine.
 40. The device as recited inclaim 38, wherein, in said executing the script, the interpreter engineis further executable by the processor to: generate an intermediaterepresentation of the script; and execute the intermediaterepresentation to produce results in accordance with the originalscript.
 41. The device as recited in claim 40, wherein, in saidexecuting the intermediate representation, the interpreter engine isfurther executable by the processor to interpret and execute each of oneor more instructions of the intermediate representation.
 42. The deviceas recited in claim 40, wherein, in said executing the intermediaterepresentation, the interpreter engine is further executable by theprocessor to access one or more program objects from one or more objectlibraries to implement one or more instructions of the intermediaterepresentation.
 43. The device as recited in claim 38, wherein each ofthe one or more instructions of the intermediate representation isrepresented as one or more Java objects each referencing one of the oneor more program objects accessed in implementing the one or moreinstructions of the intermediate representation.
 44. The device asrecited in claim 38, wherein the script language is JavaScript.
 45. Thedevice as recited in claim 38, wherein, in said detecting the script,the Web browser is further executable by the processor to detect amarkup language tag identifying the start of the script.
 46. A system,comprising: a device; a Java Virtual Machine executable within thedevice; an interpreter engine executable within the device; and a Webbrowser executable within the Java Virtual Machine to: detect one ormore script language instructions in a markup language document; andpass execution to the interpreter engine in response to said detecting;wherein the interpreter engine is executable within the device to:generate an intermediate representation of the detected one or morescript language instructions; and interpret and execute each of one ormore instructions of the intermediate representation to produce resultsin accordance with the original one or more script languageinstructions; wherein, in said interpreting and executing, theinterpreter engine is further executable within the device to access oneor more program objects to implement the one or more instructions of theintermediate representation.
 47. The system as recited in claim 46,wherein, in said generating an intermediate representation of the one ormore script language instructions, the interpreter engine is furtherexecutable to modify a first of the one or more program objects.
 48. Thesystem as recited in claim 46, wherein the one or more program objectsare accessed from one or more object libraries.
 49. The system asrecited in claim 46, wherein the script language is JavaScript.
 50. Thesystem as recited in claim 46, wherein each of the one or moreinstructions of the intermediate representation is represented as one ormore Java objects each referencing one of the one or more programobjects accessed in implementing the one or more instructions of theintermediate representation.
 51. The system as recited in claim 46,wherein the one or more program objects are Java programming languageobjects.
 52. A carrier medium comprising program instructions, whereinthe program instructions are computer-executable to implement: a firstprocess detecting one or more script language instructions in a markuplanguage document, wherein the first process is implemented in aplatform-independent programming language; generating an intermediaterepresentation of the one or more script language instructions, whereinthe intermediate representation of the one or more script languageinstructions is different from the script language; and interpreting andexecuting each of one or more instructions of the intermediaterepresentation, wherein said interpreting and executing accesses one ormore program objects to implement the one or more instructions of theintermediate representation; wherein said interpreting and executingproduces results in accordance with the original one or more scriptlanguage instructions.
 53. The carrier medium as recited in claim 52,wherein the first process is a web browser, wherein the programinstructions are further computer-executable to implement: the Webbrowser passing execution to an interpreter engine after said detectingthe one or more script language instructions in the markup languagedocument; wherein said generating, said interpreting and executing, andsaid accessing one or more program objects are performed by theinterpreter engine.
 54. The carrier medium as recited in claim 52,wherein, in said generating an intermediate representation of the one ormore script language instructions, the program instructions are furthercomputer-executable to implement modifying a first of the one or moreprogram objects.
 55. The carrier medium as recited in claim 52, whereinthe script language is JavaScript.
 56. The carrier medium as recited inclaim 52, wherein the one or more program objects are Java programminglanguage objects, and wherein each of the one or more instructions ofthe intermediate representation is represented as one or more Javaobjects each referencing one of the one or more program objects accessedin implementing the one or more instructions of the intermediaterepresentation.
 57. The carrier medium as recited in claim 52, whereinthe first process is a Java-based Web browser executing within a JavaVirtual Machine.